#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <vector>
#include <string>
#include <mutex>
#include <thread>
#include <atomic>
#include <condition_variable>
#include <memory>
#include <list>

class stackOnly
{
public:
	static stackOnly createobjonst()
	{
		return stackOnly();
	}

	void* operator new(size_t arg) = delete;
	void operator delete(void* inst) = delete;

private:
	stackOnly()
		:_arg(0)
	{

	}
	int _arg;
};

class heapOnly
{
public:
	static heapOnly* createobjonheap()
	{
		return new heapOnly;
	}

	heapOnly& operator=(const heapOnly& obj) = delete;
	heapOnly(const heapOnly& obj) = delete;

private:
	heapOnly()
		:_arg(0)
	{

	}
	int _arg;
};

class noDerivedClass final
{
public:
	noDerivedClass()
		:_arg(0)
	{

	}

	int method(int arg)
	{
		return arg + _arg;
	}

	~noDerivedClass()
	{

	}
private:
	int _arg;
};

class sinInstoninteeval
{
public:
	static sinInstoninteeval* getInstance()
	{
		return &_sI;
	}

	sinInstoninteeval(const sinInstoninteeval&) = delete;
	const sinInstoninteeval& operator=(const sinInstoninteeval&) = delete;
private:
	sinInstoninteeval()
		:_arg(0)
	{

	}
	int _arg;
	static sinInstoninteeval _sI;
};
sinInstoninteeval sinInstoninteeval::_sI;

class sinInstonlazyeval
{
public:
	static sinInstonlazyeval* getInstance()
	{
		static sinInstonlazyeval _sI;
		return &_sI;
	}

	sinInstonlazyeval(const sinInstonlazyeval&) = delete;
	const sinInstonlazyeval& operator=(const sinInstonlazyeval&) = delete;
private:
	sinInstonlazyeval()
		:_arg(0)
	{

	}
	int _arg;
};

int main()
{
	
	return 0;
}